home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1999 / MacHack 1999.toast / The Hacks / 42 ƒ / StupidWay.c < prev    next >
Encoding:
Text File  |  1999-06-26  |  14.4 KB  |  625 lines  |  [TEXT/CWIE]
  1. // StupidWay.c
  2. // Handle Life propagation the stupid, but simple way
  3. // Copyright ©1995 Michael D. Crawford.  All Rights Reserved.
  4. // 23 Jun 95 Mike Crawford crawford@scruznet.com
  5. //
  6. // Revision History:
  7. // 27 Apr 97    DGC    New today
  8.  
  9. #include <QDOffscreen.h>
  10. #include "LifeModule.h"
  11. #include "StupidWay.h"
  12. void draw_line(vector unsigned short line, vector unsigned char * ptr,Handle ThePrivateData);
  13.  
  14. typedef union
  15. {
  16.     vector unsigned char v;
  17.     unsigned char c;
  18. } vChar;
  19.  
  20. int __stupid_start(void);
  21. int __stupid_start(void)
  22. {
  23. }
  24.  
  25. OSErr PIDrawACell(Handle ThePrivateData,long x, long y)
  26. {
  27.     return 0;
  28. }
  29.  
  30. OSErr PICreateLife(Handle ThePrivateData,
  31.                 unsigned long    *life_base,
  32.                 short rowbytes,
  33.                 long color)
  34. {
  35.     if (ThePrivateData == nil)
  36.         return -1;
  37.         
  38.     SetHandleSize(ThePrivateData,sizeof(tStupidData));
  39.     if(!(((tStupidPtr)*ThePrivateData)->myDataTic = NewHandleClear(16*128)))
  40.     {
  41.         SetHandleSize(ThePrivateData, 0);
  42.         return -1;
  43.     }
  44.     if(!(((tStupidPtr)*ThePrivateData)->myDataToc = NewHandleClear(16*128)))
  45.     {
  46.         DisposeHandle(((tStupidPtr)*ThePrivateData)->myDataTic);
  47.         SetHandleSize(ThePrivateData, 0);
  48.         return -1;
  49.     }
  50.     
  51.     ((tStupidPtr)*ThePrivateData)->height = 128;
  52.     ((tStupidPtr)*ThePrivateData)->width = 128;
  53.     ((tStupidPtr)*ThePrivateData)->life_base = life_base;
  54.     ((tStupidPtr)*ThePrivateData)->rowbytes = rowbytes;
  55.     ((tStupidPtr)*ThePrivateData)->color = color;
  56.     ((tStupidPtr)*ThePrivateData)->tic = true;
  57.     return noErr;
  58. }
  59.  
  60. void PISetColor(Handle ThePrivateData, long color)
  61. {
  62.     ((tStupidPtr)*ThePrivateData)->color = color;
  63. }
  64.  
  65. OSErr PITrashLife(Handle ThePrivateData)
  66. {
  67.     if (ThePrivateData)
  68.     {
  69.         if (((tStupidPtr)*ThePrivateData)->myDataTic)
  70.         {
  71.             DisposeHandle(ThePrivateData);
  72.             ((tStupidPtr)*ThePrivateData)->myDataTic = 0;
  73.         }
  74.         if (((tStupidPtr)*ThePrivateData)->myDataToc)
  75.         {
  76.             DisposeHandle(ThePrivateData);
  77.             ((tStupidPtr)*ThePrivateData)->myDataToc = 0;
  78.         }
  79.     }
  80.     return noErr;
  81. }
  82.  
  83. OSErr PISetACell(Handle ThePrivateData,long x, long y, Boolean state)
  84. {
  85.     vChar myX;
  86.     
  87.     vector unsigned char vX;    
  88.     vector unsigned char temp = (vector unsigned char)(0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
  89.  
  90.     myX.c = x;
  91.     vX = vec_splat(myX.v,0);
  92.     
  93.     temp = vec_srl(temp,vX);
  94.     temp = vec_sro(temp,vX);
  95.     
  96.     if (((tStupidPtr)*ThePrivateData)->tic)
  97.         ((vector unsigned char *)(*((tStupidPtr)*ThePrivateData)->myDataTic))[y] = temp;
  98.     else
  99.         ((vector unsigned char *)(*((tStupidPtr)*ThePrivateData)->myDataToc))[y] = temp;
  100.     return noErr;
  101. }
  102.  
  103. Boolean PIReadACell(Handle ThePrivateData,long x, long y)
  104. {
  105.     vChar myX;
  106.     
  107.     vector unsigned char vX;    
  108.     vector unsigned char data;
  109.     vector unsigned char zero = (vector unsigned char)(0);
  110.     vector unsigned char temp = (vector unsigned char)(0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
  111.  
  112.     myX.c = x;
  113.     vX = vec_splat(myX.v,0);
  114.     
  115.     temp = vec_srl(temp,vX);
  116.     temp = vec_sro(temp,vX);
  117.     
  118.     if (((tStupidPtr)*ThePrivateData)->tic)
  119.         data = ((vector unsigned char *)(*((tStupidPtr)*ThePrivateData)->myDataTic))[y];
  120.     else
  121.         data = ((vector unsigned char *)(*((tStupidPtr)*ThePrivateData)->myDataToc))[y];
  122.         
  123.     data = vec_and(data,temp);
  124.     
  125.     return !vec_all_eq(data,zero);
  126. }
  127.  
  128.  
  129. OSErr PINextGeneration(Handle ThePrivateData)
  130. {
  131.     long    i;
  132.     vector unsigned char line0, line1, line2, bit0, bit1, bit2, carry0, carry1,temp;
  133.     vector unsigned char zero = (vector unsigned char)(0);
  134.     vector unsigned char one = (vector unsigned char)(-1);
  135.     vector unsigned char shiftOne = (vector unsigned char)(1);
  136.     
  137.     if (ThePrivateData == nil)
  138.         return -1;
  139.     
  140.     if (((tStupidPtr)*ThePrivateData)->myDataTic == nil)
  141.         return -1;
  142.         
  143.     
  144.     if (((tStupidPtr)*ThePrivateData)->tic)
  145.     {    
  146.         line0 = zero;
  147.         line1 = zero;
  148.         line2 = ((vector unsigned char *)(*((tStupidPtr)*ThePrivateData)->myDataTic))[0];
  149.             
  150.         for (i=0; i< 128; i++)
  151.         {
  152.             line0 = line1;
  153.             line1 = line2;
  154.             if (i!=127)
  155.                 line2 = ((vector unsigned char *)(*((tStupidPtr)*ThePrivateData)->myDataTic))[i+1];
  156.             else
  157.                 line2 = zero;
  158.                 
  159.             bit0 = zero;
  160.             bit1 = zero; 
  161.             bit2 = one;
  162.             
  163.             temp = line0;
  164.             carry0 = vec_and(bit0,temp);
  165.             bit0   = vec_xor(bit0,temp);
  166.             carry1 = vec_and(bit1,carry0);
  167.             bit1   = vec_xor(bit1,carry0);
  168.             bit2   = vec_xor(bit2,carry1);
  169.             
  170.             temp = vec_sll(line0,shiftOne);
  171.             carry0 = vec_and(bit0,temp);
  172.             bit0   = vec_xor(bit0,temp);
  173.             carry1 = vec_and(bit1,carry0);
  174.             bit1   = vec_xor(bit1,carry0);
  175.             bit2   = vec_xor(bit2,carry1);
  176.         
  177.             temp = vec_srl(line0,shiftOne);
  178.             carry0 = vec_and(bit0,temp);
  179.             bit0   = vec_xor(bit0,temp);
  180.             carry1 = vec_and(bit1,carry0);
  181.             bit1   = vec_xor(bit1,carry0);
  182.             bit2   = vec_xor(bit2,carry1);
  183.         
  184.             temp = vec_sll(line1,shiftOne);
  185.             carry0 = vec_and(bit0,temp);
  186.             bit0   = vec_xor(bit0,temp);
  187.             carry1 = vec_and(bit1,carry0);
  188.             bit1   = vec_xor(bit1,carry0);
  189.             bit2   = vec_xor(bit2,carry1);
  190.         
  191.             temp = vec_srl(line1,shiftOne);
  192.             carry0 = vec_and(bit0,temp);
  193.             bit0   = vec_xor(bit0,temp);
  194.             carry1 = vec_and(bit1,carry0);
  195.             bit1   = vec_xor(bit1,carry0);
  196.             bit2   = vec_xor(bit2,carry1);
  197.         
  198.             temp = line2;
  199.             carry0 = vec_and(bit0,temp);
  200.             bit0   = vec_xor(bit0,temp);
  201.             carry1 = vec_and(bit1,carry0);
  202.             bit1   = vec_xor(bit1,carry0);
  203.             bit2   = vec_xor(bit2,carry1);
  204.             
  205.             temp = vec_sll(line2,shiftOne);
  206.             carry0 = vec_and(bit0,temp);
  207.             bit0   = vec_xor(bit0,temp);
  208.             carry1 = vec_and(bit1,carry0);
  209.             bit1   = vec_xor(bit1,carry0);
  210.             bit2   = vec_xor(bit2,carry1);
  211.         
  212.             temp = vec_srl(line2,shiftOne);
  213.             carry0 = vec_and(bit0,temp);
  214.             bit0   = vec_xor(bit0,temp);
  215.             carry1 = vec_and(bit1,carry0);
  216.             bit1   = vec_xor(bit1,carry0);
  217.             bit2   = vec_xor(bit2,carry1);
  218.             
  219.             
  220.             bit1 = vec_and(bit1,bit2);
  221.             bit0 = vec_or(bit0,line1);
  222.             ((vector unsigned char *)(*((tStupidPtr)*ThePrivateData)->myDataTic))[i]    = vec_and(bit1,bit0);        
  223.         }
  224.         ((tStupidPtr)*ThePrivateData)->tic = false;
  225.     }
  226.     else
  227.     {    
  228.     
  229.         line0 = zero;
  230.         line1 = zero;
  231.         line2 = ((vector unsigned char *)(*((tStupidPtr)*ThePrivateData)->myDataToc))[0];
  232.             
  233.         for (i=0; i< 128; i++)
  234.         {
  235.             line0 = line1;
  236.             line1 = line2;
  237.             if (i!=127)
  238.                 line2 = ((vector unsigned char *)(*((tStupidPtr)*ThePrivateData)->myDataToc))[i+1];
  239.             else
  240.                 line2 = zero;
  241.                 
  242.             bit0 = zero;
  243.             bit1 = zero; 
  244.             bit2 = one;
  245.             
  246.             temp = line0;
  247.             carry0 = vec_and(bit0,temp);
  248.             bit0   = vec_xor(bit0,temp);
  249.             carry1 = vec_and(bit1,carry0);
  250.             bit1   = vec_xor(bit1,carry0);
  251.             bit2   = vec_xor(bit2,carry1);
  252.             
  253.             temp = vec_sll(line0,shiftOne);
  254.             carry0 = vec_and(bit0,temp);
  255.             bit0   = vec_xor(bit0,temp);
  256.             carry1 = vec_and(bit1,carry0);
  257.             bit1   = vec_xor(bit1,carry0);
  258.             bit2   = vec_xor(bit2,carry1);
  259.         
  260.             temp = vec_srl(line0,shiftOne);
  261.             carry0 = vec_and(bit0,temp);
  262.             bit0   = vec_xor(bit0,temp);
  263.             carry1 = vec_and(bit1,carry0);
  264.             bit1   = vec_xor(bit1,carry0);
  265.             bit2   = vec_xor(bit2,carry1);
  266.         
  267.             temp = vec_sll(line1,shiftOne);
  268.             carry0 = vec_and(bit0,temp);
  269.             bit0   = vec_xor(bit0,temp);
  270.             carry1 = vec_and(bit1,carry0);
  271.             bit1   = vec_xor(bit1,carry0);
  272.             bit2   = vec_xor(bit2,carry1);
  273.         
  274.             temp = vec_srl(line1,shiftOne);
  275.             carry0 = vec_and(bit0,temp);
  276.             bit0   = vec_xor(bit0,temp);
  277.             carry1 = vec_and(bit1,carry0);
  278.             bit1   = vec_xor(bit1,carry0);
  279.             bit2   = vec_xor(bit2,carry1);
  280.         
  281.             temp = line2;
  282.             carry0 = vec_and(bit0,temp);
  283.             bit0   = vec_xor(bit0,temp);
  284.             carry1 = vec_and(bit1,carry0);
  285.             bit1   = vec_xor(bit1,carry0);
  286.             bit2   = vec_xor(bit2,carry1);
  287.             
  288.             temp = vec_sll(line2,shiftOne);
  289.             carry0 = vec_and(bit0,temp);
  290.             bit0   = vec_xor(bit0,temp);
  291.             carry1 = vec_and(bit1,carry0);
  292.             bit1   = vec_xor(bit1,carry0);
  293.             bit2   = vec_xor(bit2,carry1);
  294.         
  295.             temp = vec_srl(line2,shiftOne);
  296.             carry0 = vec_and(bit0,temp);
  297.             bit0   = vec_xor(bit0,temp);
  298.             carry1 = vec_and(bit1,carry0);
  299.             bit1   = vec_xor(bit1,carry0);
  300.             bit2   = vec_xor(bit2,carry1);
  301.             
  302.             
  303.             bit1 = vec_and(bit1,bit2);
  304.             bit0 = vec_or(bit0,line1);
  305.             ((vector unsigned char *)(*((tStupidPtr)*ThePrivateData)->myDataToc))[i]    = vec_and(bit1,bit0);            
  306.         }
  307.         ((tStupidPtr)*ThePrivateData)->tic = true;
  308.     }
  309.     
  310.     return noErr;
  311. }
  312.  
  313. OSErr PIDrawBoard(Handle ThePrivateData)
  314. {
  315.     long    y, rowbytes;
  316.     vector unsigned char * data;
  317.     vector unsigned char * ptr;
  318.     vector unsigned char line;
  319.     
  320.     if (ThePrivateData == nil)
  321.         return 0;
  322.     
  323.     if (((tStupidPtr)*ThePrivateData)->myDataTic == nil)
  324.         return 0;
  325.  
  326.     data = (vector unsigned char *)(((tStupidPtr)*ThePrivateData)->life_base);
  327.     
  328.     rowbytes = ((tStupidPtr)*ThePrivateData)->rowbytes/4;
  329.     
  330.     for (y=0;y<128;y++)
  331.     {
  332.         ptr = data;
  333.         
  334.         if (((tStupidPtr)*ThePrivateData)->tic)
  335.         {
  336.             line = ((vector unsigned char *)(*((tStupidPtr)*ThePrivateData)->myDataTic))[y];
  337.             draw_line((vector unsigned short) line, ptr, ThePrivateData);
  338.         }
  339.         else
  340.         {
  341.             line = ((vector unsigned char *)(*((tStupidPtr)*ThePrivateData)->myDataToc))[y];
  342.             draw_line((vector unsigned short) line, ptr, ThePrivateData);
  343.         }
  344.     
  345.         data += rowbytes;
  346.     }
  347.     return noErr;
  348. }
  349.  
  350. void draw_line(vector unsigned short line, vector unsigned char * ptr,Handle ThePrivateData)
  351. {
  352.     long j = 0;
  353.     vector unsigned char cline;
  354.     vector unsigned char t1;
  355.     vector unsigned char t2;
  356.     vector unsigned char t3;
  357.     vector unsigned char t4;
  358.     vector unsigned char t5;
  359.     vector unsigned char out;
  360.     
  361.     vector unsigned char one = (vector unsigned char)(1);
  362.     vector unsigned char shift_1 = (vector unsigned char)(4,0,4,0,4,0,4,0,4,0,4,0,4,0,4,0);
  363.     vector unsigned char shift_2 = (vector unsigned char)(2,0,2,0,2,0,2,0,2,0,2,0,2,0,2,0);
  364.     vector unsigned char shift_3 = (vector unsigned char)(1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0);
  365.     vector unsigned char white = (vector unsigned char)(-1);
  366.     vector unsigned char color;
  367.     
  368.     color = *(vector unsigned char*)&(((tStupidPtr)*ThePrivateData)->color) ;
  369.     
  370.     color = (vector unsigned char)vec_splat((vector unsigned long)color,0);
  371.     
  372.     cline = (vector unsigned char)line;
  373.     
  374.     t1 = vec_mergeh(cline,cline);
  375.     t1 = vec_sr(t1,shift_1);
  376.     {
  377.         t2 = vec_mergeh(t1,t1);
  378.         t2 = vec_sr(t2,shift_2);
  379.         {
  380.             t3 = vec_mergeh(t2,t2);
  381.             t3 = vec_sr(t3,shift_3);
  382.  
  383.             t3 = vec_and(t3,one);
  384.             t3 = (vector unsigned char)vec_cmpeq(t3,one);
  385.             {        
  386.                 t4 = vec_mergeh(t3,t3);
  387.                 {        
  388.                     t5 = vec_mergeh(t4,t4);
  389.                     out = vec_sel(white,color, t5);
  390.                     ptr[j++] = out;
  391.  
  392.                     t5 = vec_mergel(t4,t4);
  393.                     out = vec_sel(white,color, t5);
  394.                     ptr[j++] = out;
  395.                 }
  396.                 t4 = vec_mergel(t3,t3);
  397.                 {        
  398.                     t5 = vec_mergeh(t4,t4);
  399.                     out = vec_sel(white,color, t5);
  400.                     ptr[j++] = out;
  401.  
  402.                     t5 = vec_mergel(t4,t4);
  403.                     out = vec_sel(white,color, t5);
  404.                     ptr[j++] = out;
  405.                 }
  406.             }
  407.  
  408.             t3 = vec_mergel(t2,t2);
  409.             t3 = vec_sr(t3,shift_3);
  410.  
  411.             t3 = vec_and(t3,one);
  412.             t3 = (vector unsigned char)vec_cmpeq(t3,one);
  413.             {        
  414.                 t4 = vec_mergeh(t3,t3);
  415.                 {        
  416.                     t5 = vec_mergeh(t4,t4);
  417.                     out = vec_sel(white,color, t5);
  418.                     ptr[j++] = out;
  419.  
  420.                     t5 = vec_mergel(t4,t4);
  421.                     out = vec_sel(white,color, t5);
  422.                     ptr[j++] = out;
  423.                 }
  424.                 
  425.                 t4 = vec_mergel(t3,t3);
  426.                 {        
  427.                     t5 = vec_mergeh(t4,t4);
  428.                     out = vec_sel(white,color, t5);
  429.                     ptr[j++] = out;
  430.  
  431.                     t5 = vec_mergel(t4,t4);
  432.                     out = vec_sel(white,color, t5);
  433.                     ptr[j++] = out;
  434.                 }
  435.             }
  436.         }
  437.  
  438.         t2 = vec_mergel(t1,t1);
  439.         t2 = vec_sr(t2,shift_2);
  440.         {
  441.             t3 = vec_mergeh(t2,t2);
  442.             t3 = vec_sr(t3,shift_3);
  443.  
  444.             t3 = vec_and(t3,one);
  445.             t3 = (vector unsigned char)vec_cmpeq(t3,one);
  446.             {        
  447.                 t4 = vec_mergeh(t3,t3);
  448.                 {        
  449.                     t5 = vec_mergeh(t4,t4);
  450.                     out = vec_sel(white,color, t5);
  451.                     ptr[j++] = out;
  452.  
  453.                     t5 = vec_mergel(t4,t4);
  454.                     out = vec_sel(white,color, t5);
  455.                     ptr[j++] = out;
  456.                 }
  457.                 
  458.                 t4 = vec_mergel(t3,t3);
  459.                 {        
  460.                     t5 = vec_mergeh(t4,t4);
  461.                     out = vec_sel(white,color, t5);
  462.                     ptr[j++] = out;
  463.  
  464.                     t5 = vec_mergel(t4,t4);
  465.                     out = vec_sel(white,color, t5);
  466.                     ptr[j++] = out;
  467.                 }
  468.             }
  469.             t3 = vec_mergel(t2,t2);
  470.             t3 = vec_sr(t3,shift_3);
  471.  
  472.             t3 = vec_and(t3,one);
  473.             t3 = (vector unsigned char)vec_cmpeq(t3,one);
  474.             {        
  475.                 t4 = vec_mergeh(t3,t3);
  476.                 {        
  477.                     t5 = vec_mergeh(t4,t4);
  478.                     out = vec_sel(white,color, t5);
  479.                     ptr[j++] = out;
  480.  
  481.                     t5 = vec_mergel(t4,t4);
  482.                     out = vec_sel(white,color, t5);
  483.                     ptr[j++] = out;
  484.                 }
  485.                 
  486.                 t4 = vec_mergel(t3,t3);
  487.                 {        
  488.                     t5 = vec_mergeh(t4,t4);
  489.                     out = vec_sel(white,color, t5);
  490.                     ptr[j++] = out;
  491.  
  492.                     t5 = vec_mergel(t4,t4);
  493.                     out = vec_sel(white,color, t5);
  494.                     ptr[j++] = out;
  495.                 }
  496.             }
  497.         }
  498.  
  499.     }
  500.  
  501.     t1 = vec_mergel(cline,cline);
  502.     t1 = vec_sr(t1,shift_1);
  503.     {
  504.         t2 = vec_mergeh(t1,t1);
  505.         t2 = vec_sr(t2,shift_2);
  506.         {
  507.             t3 = vec_mergeh(t2,t2);
  508.             t3 = vec_sr(t3,shift_3);
  509.  
  510.             t3 = vec_and(t3,one);
  511.             t3 = (vector unsigned char)vec_cmpeq(t3,one);
  512.             {        
  513.                 t4 = vec_mergeh(t3,t3);
  514.                 {        
  515.                     t5 = vec_mergeh(t4,t4);
  516.                     out = vec_sel(white,color, t5);
  517.                     ptr[j++] = out;
  518.  
  519.                     t5 = vec_mergel(t4,t4);
  520.                     out = vec_sel(white,color, t5);
  521.                     ptr[j++] = out;
  522.                 }
  523.                 
  524.                 t4 = vec_mergel(t3,t3);
  525.                 {        
  526.                     t5 = vec_mergeh(t4,t4);
  527.                     out = vec_sel(white,color, t5);
  528.                     ptr[j++] = out;
  529.  
  530.                     t5 = vec_mergel(t4,t4);
  531.                     out = vec_sel(white,color, t5);
  532.                     ptr[j++] = out;
  533.                 }
  534.             }
  535.             t3 = vec_mergel(t2,t2);
  536.             t3 = vec_sr(t3,shift_3);
  537.  
  538.             t3 = vec_and(t3,one);
  539.             t3 = (vector unsigned char)vec_cmpeq(t3,one);
  540.             {        
  541.                 t4 = vec_mergeh(t3,t3);
  542.                 {        
  543.                     t5 = vec_mergeh(t4,t4);
  544.                     out = vec_sel(white,color, t5);
  545.                     ptr[j++] = out;
  546.  
  547.                     t5 = vec_mergel(t4,t4);
  548.                     out = vec_sel(white,color, t5);
  549.                     ptr[j++] = out;
  550.                 }
  551.                 
  552.                 t4 = vec_mergel(t3,t3);
  553.                 {        
  554.                     t5 = vec_mergeh(t4,t4);
  555.                     out = vec_sel(white,color, t5);
  556.                     ptr[j++] = out;
  557.  
  558.                     t5 = vec_mergel(t4,t4);
  559.                     out = vec_sel(white,color, t5);
  560.                     ptr[j++] = out;
  561.                 }
  562.             }
  563.         }
  564.         t2 = vec_mergel(t1,t1);
  565.         t2 = vec_sr(t2,shift_2);
  566.         {
  567.             t3 = vec_mergeh(t2,t2);
  568.             t3 = vec_sr(t3,shift_3);
  569.  
  570.             t3 = vec_and(t3,one);
  571.             t3 = (vector unsigned char)vec_cmpeq(t3,one);
  572.             {        
  573.                 t4 = vec_mergeh(t3,t3);
  574.                 {        
  575.                     t5 = vec_mergeh(t4,t4);
  576.                     out = vec_sel(white,color, t5);
  577.                     ptr[j++] = out;
  578.  
  579.                     t5 = vec_mergel(t4,t4);
  580.                     out = vec_sel(white,color, t5);
  581.                     ptr[j++] = out;
  582.                 }
  583.                 
  584.                 t4 = vec_mergel(t3,t3);
  585.                 {        
  586.                     t5 = vec_mergeh(t4,t4);
  587.                     out = vec_sel(white,color, t5);
  588.                     ptr[j++] = out;
  589.  
  590.                     t5 = vec_mergel(t4,t4);
  591.                     out = vec_sel(white,color, t5);
  592.                     ptr[j++] = out;
  593.                 }
  594.             }
  595.             t3 = vec_mergel(t2,t2);
  596.             t3 = vec_sr(t3,shift_3);
  597.  
  598.             t3 = vec_and(t3,one);
  599.             t3 = (vector unsigned char)vec_cmpeq(t3,one);
  600.             {        
  601.                 t4 = vec_mergeh(t3,t3);
  602.                 {        
  603.                     t5 = vec_mergeh(t4,t4);
  604.                     out = vec_sel(white,color, t5);
  605.                     ptr[j++] = out;
  606.  
  607.                     t5 = vec_mergel(t4,t4);
  608.                     out = vec_sel(white,color, t5);
  609.                     ptr[j++] = out;
  610.                 }
  611.                 
  612.                 t4 = vec_mergel(t3,t3);
  613.                 {        
  614.                     t5 = vec_mergeh(t4,t4);
  615.                     out = vec_sel(white,color, t5);
  616.                     ptr[j++] = out;
  617.  
  618.                     t5 = vec_mergel(t4,t4);
  619.                     out = vec_sel(white,color, t5);
  620.                     ptr[j++] = out;
  621.                 }
  622.             }
  623.         }
  624.     }
  625. }